{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\h5py\\__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n"
     ]
    }
   ],
   "source": [
    "\"\"\"A very simple MNIST classifier.\n",
    "See extensive documentation at\n",
    "https://www.tensorflow.org/get_started/mnist/beginners\n",
    "\"\"\"\n",
    "from __future__ import absolute_import\n",
    "from __future__ import division\n",
    "from __future__ import print_function\n",
    "\n",
    "import argparse\n",
    "import sys\n",
    "\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "#可视化\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "FLAGS = None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们在这里调用系统提供的Mnist数据函数为我们读入数据，如果没有下载的话则进行下载。\n",
    "\n",
    "<font color=#ff0000>**这里将data_dir改为适合你的运行环境的目录**</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-2-1f2e3e29ecda>:3: read_data_sets (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:260: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please write your own downloading logic.\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:262: extract_images (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting Mnist_data/train-images-idx3-ubyte.gz\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:267: extract_labels (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting Mnist_data/train-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:110: dense_to_one_hot (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.one_hot on tensors.\n",
      "Extracting Mnist_data/t10k-images-idx3-ubyte.gz\n",
      "Extracting Mnist_data/t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:290: DataSet.__init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "(55000, 784) (55000, 10)\n"
     ]
    }
   ],
   "source": [
    "# Import data\n",
    "data_dir = 'Mnist_data/'\n",
    "mnist = input_data.read_data_sets(data_dir, one_hot=True)\n",
    "print(mnist.train.images.shape,mnist.train.labels.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义各层神经元数量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_input_layer = 28 * 28  # 输入层\n",
    "n_output_layer = 10  # 输出层\n",
    "\n",
    "# 层数的选择：线性数据使用1层，非线性数据使用2层, 超级非线性使用3+层。层数、神经元过多会导致过拟合\n",
    "n_layer_1 = 800  # hide layer\n",
    "n_layer_2 = 1000  # hide layer\n",
    "n_layer_3 = 800  # hide layer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "修改隐层神经元数量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义3隐层神经网络\n",
    "def neural_network(x):\n",
    "    # 定义第一层\"神经元\"的权重和biases\n",
    "    layer_1_w_b = {'w_': tf.Variable(tf.random_normal([n_input_layer, n_layer_1])),\n",
    "                   'b_': tf.Variable(tf.random_normal([n_layer_1]))}\n",
    "    # 定义第二层\"神经元\"的权重和biases\n",
    "    layer_2_w_b = {'w_': tf.Variable(tf.random_normal([n_layer_1, n_layer_2])),\n",
    "                   'b_': tf.Variable(tf.random_normal([n_layer_2]))}\n",
    "    # 定义第三层\"神经元\"的权重和biases\n",
    "    layer_3_w_b = {'w_': tf.Variable(tf.random_normal([n_layer_2, n_layer_3])),\n",
    "                   'b_': tf.Variable(tf.random_normal([n_layer_3]))}\n",
    "    # 定义输出层\"神经元\"的权重和biases\n",
    "    layer_output_w_b = {'w_': tf.Variable(tf.random_normal([n_layer_3, n_output_layer])),\n",
    "                        'b_': tf.Variable(tf.random_normal([n_output_layer]))}\n",
    " \n",
    "    # w·x+b\n",
    "    layer_1 = tf.add(tf.matmul(x, layer_1_w_b['w_']), layer_1_w_b['b_'])\n",
    "    layer_1 = tf.nn.selu(layer_1)  # 激活函数 relu sigmoid  tanh elu  softplus\n",
    "    layer_2 = tf.add(tf.matmul(layer_1, layer_2_w_b['w_']), layer_2_w_b['b_'])\n",
    "    layer_2 = tf.nn.selu(layer_2)  # 激活函数\n",
    "    layer_3 = tf.add(tf.matmul(layer_2, layer_3_w_b['w_']), layer_3_w_b['b_'])\n",
    "    layer_3 = tf.nn.selu(layer_3)  # 激活函数\n",
    "    layer_output = tf.add(tf.matmul(layer_3, layer_output_w_b['w_']), layer_output_w_b['b_'])\n",
    " \n",
    "    return layer_output, layer_1_w_b, layer_2_w_b, layer_3_w_b, layer_output_w_b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 每次使用100条数据进行训练\n",
    "batch_size = 100\n",
    "\n",
    "x = tf.placeholder(dtype=tf.float32, shape=[None, n_input_layer])   # 输入数据占位符\n",
    "y = tf.placeholder(dtype=tf.float32, shape=[None, n_output_layer])   # 输出数据占位符"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 使用数据训练神经网络\n",
    "def train_neural_network(X, Y, epochs=10):\n",
    "    #创建神经网络\n",
    "    y, layer_1_w_b, layer_2_w_b, layer_3_w_b, layer_output_w_b = neural_network(X)\n",
    "    #代价函数\n",
    "    cost_func = tf.reduce_sum(tf.nn.softmax_cross_entropy_with_logits(logits= y, labels=Y))\n",
    "    #惩罚因子\n",
    "    lamda = 0.1\n",
    "    #将变量的L2正则化损失添加到集合中\n",
    "    tf.add_to_collection(\"losses\",tf.contrib.layers.l2_regularizer(lamda)(layer_1_w_b['w_']))\n",
    "    tf.add_to_collection(\"losses\",tf.contrib.layers.l2_regularizer(lamda)(layer_2_w_b['w_']))\n",
    "    tf.add_to_collection(\"losses\",tf.contrib.layers.l2_regularizer(lamda)(layer_3_w_b['w_']))\n",
    "    tf.add_to_collection(\"losses\",tf.contrib.layers.l2_regularizer(lamda)(layer_output_w_b['w_']))\n",
    "    #将代价函数与正则项合并\n",
    "    tf.add_to_collection(\"losses\",cost_func)\n",
    "    #获取整个模型的损失函数,tf.get_collection(\"losses\")返回集合中定义的损失\n",
    "    #将整个集合中的损失相加得到整个模型的损失函数\n",
    "    loss = tf.add_n(tf.get_collection(\"losses\"))\n",
    "\n",
    "    #学习速率，随迭代次数进行递减\n",
    "    global_step = tf.Variable(0, trainable=False)\n",
    "    starter_learning_rate = 0.0005\n",
    "    learning_rate = tf.train.exponential_decay(starter_learning_rate, global_step, 5000, 0.96, staircase=True)\n",
    "    optimizer = tf.train.RMSPropOptimizer(learning_rate).minimize(loss)  \n",
    "    # AdamOptimizer RMSPropOptimizer 表现最好\n",
    "    # AdamOptimizer GradientDescentOptimizer AdadeltaOptimizer FtrlOptimizer ProximalGradientDescentOptimizer \n",
    "    # ProximalAdagradOptimizer RMSPropOptimizer\n",
    " \n",
    "    with tf.Session() as session:\n",
    "        session.run(tf.initialize_all_variables())\n",
    "        \n",
    "        correct = tf.equal(tf.argmax(y, 1), tf.argmax(Y, 1))\n",
    "        accuracy = tf.reduce_mean(tf.cast(correct, 'float'))\n",
    "        \n",
    "        epoch_loss = 0\n",
    "        epoch_loss_mat = []\n",
    "        epoch_accuracy_mat = []\n",
    "        epoch_accuracy_t_mat = []\n",
    "        for epoch in range(epochs):\n",
    "            for i in range(int(mnist.train.num_examples / batch_size)):\n",
    "                batch_xs, batch_ys = mnist.train.next_batch(batch_size)\n",
    "                _, c = session.run([optimizer, loss], feed_dict={X: batch_xs, Y: batch_ys})\n",
    "                epoch_loss += c\n",
    "            epoch_accuracy = accuracy.eval({X: mnist.train.images, Y: mnist.train.labels})\n",
    "            epoch_accuracy_t = accuracy.eval({X: mnist.test.images, Y: mnist.test.labels})\n",
    "            print('epoch ', epoch, ' loss      : ', epoch_loss)\n",
    "            print('epoch ', epoch, ' accuracy  : ', epoch_accuracy)\n",
    "            print('epoch ', epoch, ' accuracy_t: ', epoch_accuracy_t)\n",
    "            epoch_loss_mat.append(epoch_loss)\n",
    "            epoch_accuracy_mat.append(epoch_accuracy)\n",
    "            epoch_accuracy_t_mat.append(epoch_accuracy_t)\n",
    "            epoch_loss = 0\n",
    " \n",
    "        \n",
    "        print('训练准确率: ', accuracy.eval({X: mnist.train.images, Y: mnist.train.labels}))\n",
    "        print('测试准确率: ', accuracy.eval({X: mnist.test.images, Y: mnist.test.labels}))\n",
    "        \n",
    "        plt.plot(range(epochs), epoch_loss_mat) \n",
    "        plt.xlabel('epochs')\n",
    "        plt.ylabel('epoch_loss')\n",
    "        plt.show() \n",
    "        \n",
    "        plt.plot(range(epochs), epoch_accuracy_mat, label='Train Accuracy') \n",
    "        plt.plot(range(epochs), epoch_accuracy_t_mat, label='Test Accuracy')\n",
    "        plt.legend()\n",
    "        plt.xlabel('epochs')\n",
    "        plt.ylabel('accuracy')\n",
    "        plt.show() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-6-d9260810edfe>:6: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "\n",
      "Future major versions of TensorFlow will allow gradients to flow\n",
      "into the labels input on backprop by default.\n",
      "\n",
      "See @{tf.nn.softmax_cross_entropy_with_logits_v2}.\n",
      "\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\util\\tf_should_use.py:118: initialize_all_variables (from tensorflow.python.ops.variables) is deprecated and will be removed after 2017-03-02.\n",
      "Instructions for updating:\n",
      "Use `tf.global_variables_initializer` instead.\n",
      "epoch  0  loss      :  505926103.96875\n",
      "epoch  0  accuracy  :  0.9191273\n",
      "epoch  0  accuracy_t:  0.9083\n",
      "epoch  1  loss      :  170929253.875\n",
      "epoch  1  accuracy  :  0.9543091\n",
      "epoch  1  accuracy_t:  0.9301\n",
      "epoch  2  loss      :  117116216.2265625\n",
      "epoch  2  accuracy  :  0.9669818\n",
      "epoch  2  accuracy_t:  0.9384\n",
      "epoch  3  loss      :  91785815.5625\n",
      "epoch  3  accuracy  :  0.9779091\n",
      "epoch  3  accuracy_t:  0.9407\n",
      "epoch  4  loss      :  75913224.3515625\n",
      "epoch  4  accuracy  :  0.9784\n",
      "epoch  4  accuracy_t:  0.9401\n",
      "epoch  5  loss      :  67443947.6171875\n",
      "epoch  5  accuracy  :  0.98892725\n",
      "epoch  5  accuracy_t:  0.949\n",
      "epoch  6  loss      :  62034767.40625\n",
      "epoch  6  accuracy  :  0.9910727\n",
      "epoch  6  accuracy_t:  0.949\n",
      "epoch  7  loss      :  58906334.6484375\n",
      "epoch  7  accuracy  :  0.9932727\n",
      "epoch  7  accuracy_t:  0.9523\n",
      "epoch  8  loss      :  56588534.5546875\n",
      "epoch  8  accuracy  :  0.9944\n",
      "epoch  8  accuracy_t:  0.9539\n",
      "epoch  9  loss      :  54751823.8203125\n",
      "epoch  9  accuracy  :  0.9956\n",
      "epoch  9  accuracy_t:  0.9529\n",
      "epoch  10  loss      :  53360241.1484375\n",
      "epoch  10  accuracy  :  0.9958\n",
      "epoch  10  accuracy_t:  0.9571\n",
      "epoch  11  loss      :  52239209.8046875\n",
      "epoch  11  accuracy  :  0.995\n",
      "epoch  11  accuracy_t:  0.9545\n",
      "epoch  12  loss      :  51664752.5703125\n",
      "epoch  12  accuracy  :  0.99521816\n",
      "epoch  12  accuracy_t:  0.9555\n",
      "epoch  13  loss      :  50119773.9375\n",
      "epoch  13  accuracy  :  0.9959273\n",
      "epoch  13  accuracy_t:  0.9573\n",
      "epoch  14  loss      :  49667879.9140625\n",
      "epoch  14  accuracy  :  0.9942727\n",
      "epoch  14  accuracy_t:  0.9569\n",
      "epoch  15  loss      :  48841272.3984375\n",
      "epoch  15  accuracy  :  0.9948\n",
      "epoch  15  accuracy_t:  0.9545\n",
      "epoch  16  loss      :  48085980.1875\n",
      "epoch  16  accuracy  :  0.9968727\n",
      "epoch  16  accuracy_t:  0.9571\n",
      "epoch  17  loss      :  47395497.953125\n",
      "epoch  17  accuracy  :  0.99521816\n",
      "epoch  17  accuracy_t:  0.9583\n",
      "epoch  18  loss      :  46942824.6015625\n",
      "epoch  18  accuracy  :  0.9932\n",
      "epoch  18  accuracy_t:  0.9576\n",
      "epoch  19  loss      :  46313469.6484375\n",
      "epoch  19  accuracy  :  0.99716365\n",
      "epoch  19  accuracy_t:  0.9599\n",
      "训练准确率:  0.99716365\n",
      "测试准确率:  0.9599\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_neural_network(X=x, Y=y, epochs=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "毫无疑问，这个模型是一个非常简陋，性能也不理想的模型。目前只能达到92%左右的准确率。\n",
    "接下来，希望大家利用现有的知识，将这个模型优化至98%以上的准确率。\n",
    "Hint：\n",
    "- 多隐层\n",
    "- 激活函数\n",
    "- 正则化\n",
    "- 初始化\n",
    "- 摸索一下各个超参数\n",
    "  - 隐层神经元数量\n",
    "  - 学习率\n",
    "  - 正则化惩罚因子\n",
    "  - 最好每隔几个step就对loss、accuracy等等进行一次输出，这样才能有根据地进行调整"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
